# -*-coding: utf-8 -*-

##
 # Esse arquivo é parte do Software Encainador
 # 
 # Copyright (C) 2011-$AnoCorrente$ Dyego Ítallo Silva Ferreira
 # Copyright (C) 2011-$AnoCorrente$ Marcos José Ferreira Neto
 # Copyright (C) 2011-$AnoCorrente$ Eduardo Moreira Barbosa
 # Copyright (C) 2011-$AnoCorrente$ Rogério Silva dos Santos
 # 
 # Encainador é um Software Livre: Você pode redistribuí-lo e/ou modificá-lo
 # de acordo com os termos da Licença Pública Geral GNU (GNU General Public License)
 # conforme publicada pela Free Software Foundation (FSF). Essa permissão é atribuída
 # na versão 3 da Licença, ou (na sua opinião) qualquer versão.
 # 
 # Você deve ter recebido uma cópia da Licença Pública Geral GNU junto com este programa,
 # se não, escreva para a Fundação do Software Livre(FSF) Inc., 51 Franklin St, Fifth Floor,
 # Boston, MA  02110-1301  USA
 # 
 # Se você tiver alguma dúvida e/ou quiser dar suporte ao desenvolvimento, favor entrar em
 # contato nos e-mails <dyegoitallo@gmail.com>, <marcosjfneto@gmail.com>, <barbosa.edrd@gmail.com>, <roger.silva23@hotmail.com>.
##

import pygame
from pygame.locals import *
from sys import exit
import os
import random
import time
from fases import *
from Menu import menu
from animacao_menu import*
from historico_de_ganhadores import recordes_escrever

branco = (255, 255, 255)
vermelho = (255, 0, 0)
azul = (0, 0, 255)

pygame.display.set_caption("EnCAInaDOR")


#IMAGENS#
cano_I_N = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "I" + os.sep + "Cano_I.png")
cano_I_P = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "I" + os.sep + "Cano_I_Personalizado.png")
cano_L_N = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "L" + os.sep + "Cano_L.png")
cano_L_P = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "L" + os.sep + "Cano_L_Personalizado.png")
cano_LL_N = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "LL" + os.sep + "Cano_LL.png")
cano_LL_P = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "LL" + os.sep + "Cano_LL_Personalizado.png")
cano_R = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "registro" + os.sep + "Registro_1.png")
cano_Final = pygame.image.load("imagens" + os.sep + "canos" + os.sep + "final" + os.sep + "Cano_F.png")
borda = pygame.image.load("imagens" + os.sep + "outros" + os.sep + "Borda.png")
tela_resultado = pygame.image.load("imagens" + os.sep + "outros" + os.sep + "Resultado.png")
barra = pygame.image.load("imagens" + os.sep + "outros" + os.sep + "Barra.png")
fundo = pygame.image.load("imagens" + os.sep + "outros" + os.sep + "Fundo.png")


cano_f = []
cano_L_a = []
cano_L_b = []
cano_I_c = []
cano_I_d = []
cano_r_pintado = []
cano_r_giro = []
cano_LL_a = []
cano_LL_b = []

for x in range(1,6):
    cano_f += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "final" + os.sep + "Cano_F_Pintado%s.png" %x)]
    cano_L_a += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "L" + os.sep + "Cano_L_Pintado_a%s.png"%x)]
    cano_L_b += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "L" + os.sep + "Cano_L_Pintado_b%s.png"%x)]
    cano_I_c += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "I" + os.sep + "Cano_I_Pintado_c%s.png"%x)]
    cano_I_d += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "I" + os.sep + "Cano_I_Pintado_d%s.png"%x)]
    cano_r_pintado += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "registro" + os.sep + "Registro_Pintado%s.png"%x)]
    cano_r_giro += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "registro" + os.sep + "Registro_%s.png"%x)]
    cano_LL_a += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "LL" + os.sep + "Cano_LL_Pintado_a%s.png"%x)]
    cano_LL_b += [pygame.image.load("imagens" + os.sep + "canos" + os.sep + "LL" + os.sep + "Cano_LL_Pintado_b%s.png"%x)]

cano_r_giro *= 4

imagens_inunda = []
for x in range(16):
    imagens_inunda += [pygame.image.load("imagens" + os.sep + "inunda" + os.sep + "%s.png"%x)]

#SONS#
giro = pygame.mixer.Sound("sons" + os.sep + "drip.ogg")
registro_pressionado = pygame.mixer.Sound("sons" + os.sep + "aperta_registro.ogg")


# FUNÇÃO DE ESPELHAMENTO DE FASES
lista_espelhamento = [1, 2, 3, 4]
random.shuffle(lista_espelhamento)
def chama_espelha_fase(lista): # lista receberá lista_espelhamento
    jogo = dic_fases[fase_jogo]
    cano0 = jogo[0]
    caminho_inicial = jogo[1]
    ang_certo_inicial = jogo[2]


    if lista[tentativa % 4] == 1:  # 0º
        matriz_tipo = cano0[::]
        ang_certo = ang_certo_inicial[::]
        caminho_certo = caminho_inicial[::]
        return matriz_tipo, caminho_certo, ang_certo, jogo


    elif lista[tentativa % 4] == 2:  # -90º
        dic_ang2 = {-1: -3, -2: 0, -3: -1, 0: -2}
        cano2 = cano0[::]
        ang_certo2 = ang_certo_inicial[::]
        caminho2 = caminho_inicial[::]
        cano2.reverse()

        n = 0
        for x in caminho_inicial:  # gera nova matriz do caminho correto
            caminho2[n] = 59-x
            n += 1

        n = 0
        for x in ang_certo_inicial:  # gera nova matriz dos angulos
            ang_certo2[n] = dic_ang2[x]
            n+=1

        n = 0
        for x in caminho_inicial: # corrige cano I
            if cano0[x] == I:
                ang_certo2[n] = ang_certo_inicial[n]
            n += 1

        matriz_tipo, ang_certo, caminho_certo  = cano2, ang_certo2, caminho2
        return matriz_tipo, caminho_certo, ang_certo, jogo


    elif lista[tentativa % 4] == 3:  # -180º
        dic_ang3 = {0: -1, -1: 0, -3: -2, -2: -3}

        cano3 = []
        for x in range(10, 61, 10):  # inverte as linhas da matriz
            a = cano0[x-10 : x]
            a.reverse()
            for y in a:
                cano3.append(y)

        ang_certo3 = ang_certo_inicial[::]
        caminho3 = caminho_inicial[::]

        n = 0
        for x in caminho_inicial:  # gera nova matriz do caminho correto
            caminho3[n] = (x / 10) * 10 + 10 - (x % 10) -1
            n +=1

        n = 0
        for x in ang_certo_inicial:  # gera nova matriz dos angulos
            ang_certo3[n] = dic_ang3[x]
            n+=1

        n = 0
        for x in caminho_inicial: # corrige cano I
            if cano0[x] == I:
                ang_certo3[n] = ang_certo_inicial[n]
            n += 1

        matriz_tipo, ang_certo, caminho_certo  = cano3, ang_certo3, caminho3
        return matriz_tipo, caminho_certo, ang_certo, jogo


    elif lista[tentativa % 4] == 4: # -270º
        dic_ang4 = {-1: -2, -2: -1, -3: 0, 0: -3}

        cano4 = []
        for x in range(10, 61, 10): # invete as linhas da matriz
            a = cano0[x-10 : x]
            a.reverse()
            for y in a:
                cano4.append(y)

        ang_certo4 = ang_certo_inicial[::]
        caminho4 = caminho_inicial[::]
        cano4.reverse()

        n = 0
        for x in caminho_inicial: # gera nova matriz do caminho correto
            caminho4[n] = 59 - ((x / 10) * 10 + 10 - (x % 10) -1)
            n += 1

        n = 0
        for x in ang_certo_inicial: # gera nova matriz do caminho correto
            ang_certo4[n] = dic_ang4[x]
            n += 1

        n = 0
        for x in caminho_inicial: # gera nova matriz dos angulos
            if cano0[x] == I:
                ang_certo4[n] = ang_certo_inicial[n]
            n += 1

        matriz_tipo, ang_certo, caminho_certo = cano4, ang_certo4, caminho4
        return matriz_tipo, caminho_certo, ang_certo, jogo

#FUNÇÃO MOVIMENTAÇÃO E TROCA DE CANOS
movimentos = 0
def mov_imagem(angulo, mov_x, mov_y, cano_N, cano_P):
    if cano_N == cano_Final or cano_N == 0:
        cano = cano_N
        movimentos = 0
    else:
        if mov_x < pygame.mouse.get_pos()[0] < mov_x + borda.get_size()[0] and mov_y < pygame.mouse.get_pos()[1] < mov_y + borda.get_size()[1]:
            cano = cano_P
            movimentos = 0
            if pygame.mouse.get_pressed()[0] == 1 and (((pygame.mouse.get_pos()[0]-160)/borda.get_size()[0],(pygame.mouse.get_pos()[1]-85)/borda.get_size()[1]) not in parado):#######
                angulo -= 9
                giro.play()
                movimentos = 1
        else:
            cano = cano_N
            movimentos = 0
    return cano, angulo, movimentos	#Retorna o tipo de cano (Personalizado ou normal) e angulação do mesmo.


#FUNÇÃO DE PREENCIMENTO DE CANOS

#preenche os canos com água e indica a posição da próximo cana a ser analisado
def preencher_agua(lista_cano, angulo, lista_caminho_verificacao, valor_adicionar):
# a variavel valor_adicionar é responsável por indicar o próximo cano a ser analisado, dependendo do seu valor teremos um tipo especifico de retorno

    for img in lista_cano:
        cano = pygame.transform.rotate(img, angulo)
        tela.blit(cano, (posicao_x[lista_caminho_verificacao[-1]], posicao_y[lista_caminho_verificacao[-1]]))
        pygame.display.update()
        pygame.time.wait(50)

    lista_caminho_verificacao.append(lista_caminho_verificacao[-1] + valor_adicionar)

    if valor_adicionar == 1 and (lista_caminho_verificacao[-1]) % 10 == 0:
        return lista_caminho_verificacao,True

    elif valor_adicionar == -1 and (lista_caminho_verificacao[-1]) % 10 == 9:
        return lista_caminho_verificacao,True

    elif valor_adicionar == 10 and (lista_caminho_verificacao[-1]) > 59:
        return lista_caminho_verificacao,True

    elif valor_adicionar == -10 and (lista_caminho_verificacao[-1]) < 0:
        return lista_caminho_verificacao,True

    return lista_caminho_verificacao, False # retorna a posição a ser analisada e um valor booleano para preencher a tela, caso o caminho esteja errado



# FUNÇÃ PARA DETECTAR SE EH O CANO FINAL
# durante a verificação, chama as imagens do registro, do ultimo cano e as que inundam a tela caso o caminho esteja errado
def imagem_R_F_inunda(lista_cano, angulo, (posicao)):
    for img in lista_cano:
        cano = pygame.transform.rotate(img, angulo)
        tela.blit(cano, (posicao))
        pygame.display.update()
        pygame.time.wait(50)



# FUNÇÃO DE VERIFICAÇÃO SE O CARA GANHOU OU PERDEU
tentativa = 0
def verificacao(): # verifica se o caminho montado é o correto
    lista_caminho_verificacao = []

    if (pygame.mouse.get_pressed()[0] == 1 and ((pygame.mouse.get_pos()[0]-160)/borda.get_size()[0],(pygame.mouse.get_pos()[1]-85)/borda.get_size()[1]) == parado[0] and mov != 0) or tempo_restante() <= 0:
        resultado = 0
        registro_pressionado.play()

        if matriz_tipo.index(R)/10 == 0:
            posicao_2 = matriz_tipo.index(R) + 10 # a variável 'lista_caminho_verificacao[-1]' representa a última posição adicionada na lista_caminho_verificacao e que será verificada a cada iteração
            lista_caminho_verificacao.append(matriz_tipo.index(R)) # na próxima iteração
            lista_caminho_verificacao.append(posicao_2)

            imagem_R_F_inunda(cano_r_giro, 0, (posicao_x[matriz_tipo.index(R)], posicao_y[matriz_tipo.index(R)]))#
            imagem_R_F_inunda(cano_r_pintado ,0, (posicao_x[matriz_tipo.index(R)], posicao_y[matriz_tipo.index(R)]))#


        else: # essa parte é utilizada quando o registro está na última linha
            posicao_2 = matriz_tipo.index(R) - 10
            lista_caminho_verificacao.append(matriz_tipo.index(R))
            lista_caminho_verificacao.append(posicao_2)

            imagem_R_F_inunda(cano_r_giro, -180, (posicao_x[matriz_tipo.index(R)], posicao_y[matriz_tipo.index(R)]))#
            imagem_R_F_inunda(cano_r_pintado, -180, (posicao_x[matriz_tipo.index(R)], posicao_y[matriz_tipo.index(R)]))

        perdeu = False # variável que chama a tela 'perdeu', é ativada quando nenhuma das possibilidade listadas é sastifeita
        while perdeu != True:
            variacao_posicao = lista_caminho_verificacao[-1] - lista_caminho_verificacao[-2] # diferença entre as duas ultimas posições
            if matriz_tipo[lista_caminho_verificacao[-1]] == 0:
                perdeu = True

            # canos tipo I
            elif matriz_tipo[lista_caminho_verificacao[-1]] == I:
                # 1 água desce
                if (variacao_posicao == 10) and (angulo[lista_caminho_verificacao[-1]]%180 == 0):
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_I_c, 0, lista_caminho_verificacao, 10 )

                # 2 água sobe
                elif (variacao_posicao == -10) and (angulo[lista_caminho_verificacao[-1]]%180 == 0):
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_I_c, -180, lista_caminho_verificacao, -10 )

                # 3 água para direita
                elif (variacao_posicao == 1) and angulo[lista_caminho_verificacao[-1]]%180 == 90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_I_c, -270, lista_caminho_verificacao, 1 )

                # 4 água para esquerda
                elif (variacao_posicao == -1) and angulo[lista_caminho_verificacao[-1]]%180 == 90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_I_c, -90, lista_caminho_verificacao, -1 )

                else:
                    perdeu = True


            # canos tipo L
            elif matriz_tipo[lista_caminho_verificacao[-1]] == L:
                # 1 água para baixo esquerda
                if (variacao_posicao == 10) and angulo[lista_caminho_verificacao[-1]] == 0:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, 0, lista_caminho_verificacao, -1 )

                # 2 água para baixo direita
                elif (variacao_posicao == 10) and angulo[lista_caminho_verificacao[-1]] == -90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, -90, lista_caminho_verificacao, 1 )

                # 3 água para cima esquerda
                elif (variacao_posicao == -10) and angulo[lista_caminho_verificacao[-1]] == -270:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, -270, lista_caminho_verificacao, -1 )

                # 4 água para cima direita
                elif (variacao_posicao == -10) and angulo[lista_caminho_verificacao[-1]] == -180:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, -180, lista_caminho_verificacao, 1)

                # 5 água para direita sobe
                elif (variacao_posicao == 1) and angulo[lista_caminho_verificacao[-1]] == 0:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, 0, lista_caminho_verificacao, -10)

                # 6 água para direita desce
                elif (variacao_posicao == 1) and angulo[lista_caminho_verificacao[-1]] == -270:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, -270, lista_caminho_verificacao, 10)

                # 7 água para esquerda sobe
                elif (variacao_posicao == -1) and angulo[lista_caminho_verificacao[-1]] == -90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, -90,  lista_caminho_verificacao, -10 )

                # 8 água para esquerda desce
                elif (variacao_posicao == -1) and angulo[lista_caminho_verificacao[-1]] == -180:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, -180, lista_caminho_verificacao, 10 )

                else:
                    perdeu = True

            # canos tipo LL

            elif matriz_tipo[lista_caminho_verificacao[-1]] == X:

                # 1 água para baixo esquerda
                if (variacao_posicao == 10) and angulo[lista_caminho_verificacao[-1]]%180 == 0:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, 0, lista_caminho_verificacao, -1 )

                # 2 água para baixo direita
                elif (variacao_posicao == 10) and angulo[lista_caminho_verificacao[-1]]%180 == 90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, -90, lista_caminho_verificacao, 1 )

                # 3 água para acima esquerda
                elif (variacao_posicao == -10) and angulo[lista_caminho_verificacao[-1]]%180 == 90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, -270, lista_caminho_verificacao, -1 )


                # 4 água para acima direita
                elif (variacao_posicao == -10) and angulo[lista_caminho_verificacao[-1]]%180 == 0:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, -180, lista_caminho_verificacao, 1 )

                # 5 água para direita sobe
                elif (variacao_posicao == 1) and angulo[lista_caminho_verificacao[-1]]%180 == 0:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, 0, lista_caminho_verificacao, -10 )

                # 6 água para direita desce
                elif (variacao_posicao == 1) and angulo[lista_caminho_verificacao[-1]]%180 == 90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, -270, lista_caminho_verificacao, 10 )

                # 7 água para esquerda sobe
                elif (variacao_posicao == -1) and angulo[lista_caminho_verificacao[-1]]%180 == 90:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_a, -90, lista_caminho_verificacao, -10 )

                # 8 água para esquerda desce
                elif (variacao_posicao == -1) and angulo[lista_caminho_verificacao[-1]]%180 == 0:
                    lista_caminho_verificacao,perdeu = preencher_agua( cano_L_b, -180, lista_caminho_verificacao, 10 )

            # Canos do tipo F
            elif matriz_tipo[lista_caminho_verificacao[-1]] == F and variacao_posicao%10 == 0:

                if matriz_tipo.index(R)/10 == 0:
                    imagem_R_F_inunda(cano_f, 0, (posicao_x[matriz_tipo.index(F)], posicao_y[matriz_tipo.index(F)]))#

                else: #essa parte e utilizada quando o registro esta na ultima linha
                    imagem_R_F_inunda(cano_f, -180, (posicao_x[matriz_tipo.index(F)], posicao_y[matriz_tipo.index(F)]))#

                return True, True

            # Caso nenhuma das condições sejam sastifeitas
            else:
                perdeu = True

            if perdeu == True:
                imagem_R_F_inunda(imagens_inunda,0,(160, 85))#

                return False, True

    else:
        return None, False

#FUNÇÃO PARA O TEMPO RESTANTE
def tempo_restante():
    tempo = tempo_inicial - time.clock() + reseta_tempo
    if tempo < 0:
        tempo = 0
    return tempo

#FUNÇÃO DE ATUALIZAÇÃO DA TELA
def atualizacao():
    tela.fill(branco)

    tela.blit(fundo, (0, 0))
    tela.blit(barra, (35, 85))
    # colocar barra na tela
    tempo = pygame.font.Font("fonte.ttf", 20).render("Tempo", 1, branco)
    tempo_rod = pygame.font.Font("03.ttf", 30).render("%.1f" %tempo_restante(), 1, branco)
    tela.blit(tempo, (35 + barra.get_size()[0]/2 - tempo.get_size()[0]/2, 135))
    tela.blit(tempo_rod, (35 + barra.get_size()[0]/2 - tempo_rod.get_size()[0]/2, 160))

    movimentos = pygame.font.Font("fonte.ttf", 20).render("Movimentos", 1, branco)
    movimentos_rod = pygame.font.Font("03.ttf", 30).render(str(mov), 1, branco)
    tela.blit(movimentos, (35 + barra.get_size()[0]/2 - movimentos.get_size()[0]/2, 235))
    tela.blit(movimentos_rod, (35 + barra.get_size()[0]/2 - movimentos_rod.get_size()[0]/2, 265))

    fase = pygame.font.Font("fonte.ttf", 20).render("Fase", 1, branco)
    num_fase = pygame.font.Font("03.ttf", 30).render(str(fase_jogo), 1, branco)
    tela.blit(fase, (35 + barra.get_size()[0]/2 - fase.get_size()[0]/2, 335))
    tela.blit(num_fase, (35 + barra.get_size()[0]/2 - num_fase.get_size()[0]/2, 365))

    pontos = pygame.font.Font("fonte.ttf", 20).render("Pontos", 1, branco)
    num_pontos = pygame.font.Font("03.ttf", 30).render(str(pontuacao), 1, branco)
    tela.blit(pontos, (35 + barra.get_size()[0]/2 - pontos.get_size()[0]/2, 435))
    tela.blit(num_pontos, (35 + barra.get_size()[0]/2 - num_pontos.get_size()[0]/2, 465))

    for i in range(60):  # expor os canos na tela
        tela.blit(borda, (posicao_x[i], posicao_y[i]))
        if canos[i] != 0:
            cano = pygame.transform.rotate(canos[i], angulo[i])
            tela.blit(cano, (posicao_x[i], posicao_y[i]))
        if angulo[i] % 90 != 0:
            angulo[i] -= 9
            if angulo[i] <= -360:
                angulo[i] = 0
    pygame.display.update()

# FUNÇÃO MOUSE PASSANDO EM ALGUM TEXTO OU IMANGEM
def mousepassando(Botao_N, Botao_P, largura_img, altura_img):
    mouse = pygame.mouse.get_pos()
    if largura_img < mouse[0] and altura_img < mouse[1] and mouse[0] < largura_img + Botao_N.get_size()[0] and mouse[1] < altura_img + Botao_N.get_size()[1]:
        Botao = Botao_P
        if pygame.mouse.get_pressed()[0] == 1:
            mouse_pressionado = True
        else:
            mouse_pressionado = False
    else:
        Botao = Botao_N
        mouse_pressionado = False
    return Botao, (largura_img, altura_img), mouse_pressionado

pontuacao = 0
#FUNÇÃO PARA APARECER A TELA FINAL


def tela_final(fase_jogo,tentativa, pontuacao, ir_menu, nome):
    if resultado == True:
        pontuacao += int((tempo_restante()) * 10 + (150 - mov) * 5)
        if pontuacao < 0:
            pontuacao = 0
        pontuacao += 200

        if len(dic_fases) == fase_jogo:
            situacao = pygame.font.Font("02.ttf", 35).render("Jogo concluido", 1, preto)
            continuacao_N = pygame.font.Font("fonte.ttf", 30).render("", 1, preto)
            continuacao_P = pygame.font.Font("fonte.ttf", 30).render("", 1, branco)
        else:
            situacao = pygame.font.Font("02.ttf", 35).render("Parabens", 1, preto)
            continuacao_N = pygame.font.Font("fonte.ttf", 30).render("Ir para proxima fase", 1, preto)
            continuacao_P = pygame.font.Font("fonte.ttf", 30).render("Ir para proxima fase", 1, branco)

        resutado_fase = 'ganhou'
        pontos = pygame.font.Font("02.ttf", 27).render("Pontos", 1, preto)
        res_pontuacao = pygame.font.Font("02.ttf", 40).render(str(pontuacao), 1, azul)
        sair_N = pygame.font.Font("fonte.ttf", 30).render("Sair do jogo", 1, preto)
        sair_P = pygame.font.Font("fonte.ttf", 30).render("Sair do jogo", 1, branco)
    else:
        pontuacao += 0
        situacao = pygame.font.Font("02.ttf", 35).render("Jogo Perdido", 1, preto)
        pontos = pygame.font.Font("02.ttf", 27).render("Pontos", 1, preto)
        res_pontuacao = pygame.font.Font("02.ttf", 40).render(str(pontuacao), 1, vermelho)
        continuacao_N = pygame.font.Font("fonte.ttf", 30).render("Tentar de novo", 1, preto)
        continuacao_P = pygame.font.Font("fonte.ttf", 30).render("Tentar de novo", 1, branco)
        sair_N = pygame.font.Font("fonte.ttf", 30).render("Sair do jogo", 1, preto)
        sair_P = pygame.font.Font("fonte.ttf", 30).render("Sair do jogo", 1, branco)
        resutado_fase = 'perdeu'

    continuacao = continuacao_N
    sair = sair_N
    posicao_continuacao = (345 + tela_resultado.get_size()[0]/2 - continuacao.get_size()[0]/2, 380)
    posicao_sair = (345 + tela_resultado.get_size()[0]/2 - sair.get_size()[0]/2, 420)
    mouse_pressionado = False

    aux = True
    while aux and ir_menu == False:
        for evento in pygame.event.get():#
            if evento.type == QUIT:#
                exit()#
            mouse = pygame.mouse.get_pos()#

            if resutado_fase == 'perdeu':
                continuacao, posicao_continuacao, mouse_pressionado = mousepassando(continuacao_N, continuacao_P, 345 + tela_resultado.get_size()[0]/2 - continuacao.get_size()[0]/2, 380)
                if mouse_pressionado == True:
                    tentativa += 1
                    aux = False

                sair, posicao_sair, mouse_pressionado = mousepassando(sair_N, sair_P, 345 + tela_resultado.get_size()[0]/2 - sair.get_size()[0]/2, 420)
                if mouse_pressionado == True:
                    recordes_escrever(nome, pontuacao)
                    ir_menu = True
                    fase_jogo = 1
                    tentativa = 0
                    pontuacao = 0

            elif resutado_fase == 'ganhou':
                continuacao, posicao_continuacao, mouse_pressionado = mousepassando(continuacao_N, continuacao_P, 345 + tela_resultado.get_size()[0]/2 - continuacao.get_size()[0]/2, 380)
                if mouse_pressionado == True:
                    fase_jogo += 1
                    tentativa = 0
                    aux = False

                sair, posicao_sair, mouse_pressionado = mousepassando(sair_N, sair_P, 345 + tela_resultado.get_size()[0]/2 - sair.get_size()[0]/2, 420)
                if mouse_pressionado == True:
                    recordes_escrever(nome, pontuacao)
                    ir_menu = True
                    fase_jogo = 1
                    tentativa = 0
                    pontuacao = 0
                    
                    
        #tela.fill(preto)
        tela.blit(tela_resultado, (345, 190))
        # coloca tela perdedor ou ganhador
        tela.blit(situacao, (345 + tela_resultado.get_size()[0]/2 - situacao.get_size()[0]/2, 200))
        tela.blit(pontos, (345 + tela_resultado.get_size()[0]/2 - pontos.get_size()[0]/2, 270))
        tela.blit(res_pontuacao, (345 + tela_resultado.get_size()[0]/2 - res_pontuacao.get_size()[0]/2, 300))
        tela.blit(continuacao, posicao_continuacao)
        tela.blit(sair, posicao_sair)

        pygame.display.update()
    return fase_jogo,tentativa, pontuacao, ir_menu


#FUNÇÃO PARA DEIXAR OS ANGULOS ALEATÓRIOS
def modifica_angulos():
    ang_valor = [0,-90,-180,-270]

    for i in range(60): # escolhe os canos aleatoriamente
        random.shuffle(ang_valor)
        angulo[i] = ang_valor[0]

    aux = 0
    for x in caminho_certo: # não deixa que os canos fiquem no ângulo correto
        if matriz_tipo[x] == L and angulo[x]/90 == ang_certo[aux]:
            if angulo[x] != ang_valor[1]:
                angulo[x] = ang_valor[1]

            else:
                angulo[x] = ang_valor[2]

        elif (matriz_tipo[x] == I or matriz_tipo[x] == X) and (angulo[x]%180)/-90 == ang_certo[aux]: #############'	MODIFICADO ###'
            if angulo[x] != ang_valor[1]:
                angulo[x] = ang_valor[1]
            elif angulo[x] != ang_valor[2]:
                angulo[x] = ang_valor[2]
            else:
                angulo[x] = ang_valor[3]

        aux += 1

    # deixa os canos R e F com ângulo 0
    if parado[0][1] == 0:
        angulo[matriz_tipo.index(R)] = 0
        angulo[matriz_tipo.index(F)] = 0

    elif parado[0][1] == 5:
        angulo[matriz_tipo.index(R)] = 0
        angulo[matriz_tipo.index(F)] = -180

# POSICIONAMENTO DOS CANOS
posicao_x = []
posicao_y = []
for y in range(6):
    for x in range(10):
        posicao_x.append(160 + borda.get_size()[0] * x)
        posicao_y.append(85 + borda.get_size()[1] * y)

#LOOP PRINCIPAL
fase_jogo = 1
angulo = range(60)
canos = range(60)

dic_P = {0:0, L:cano_L_P, I:cano_I_P, R:cano_R, F: cano_Final, X: cano_LL_P}
dic_N = {0:0, L:cano_L_N, I:cano_I_N, R:cano_R, F: cano_Final, X: cano_LL_N}

ir_menu = True
#menu()
while True: # Loop principal

    if ir_menu == True:
        ir_menu, nome = menu()

    matriz_tipo, caminho_certo, ang_certo, jogo = chama_espelha_fase(lista_espelhamento)

    # matriz da posição das imagens fixas - R (registro) e F (final)
    parado = [(matriz_tipo.index(R)%10,matriz_tipo.index(R)/10),(matriz_tipo.index(F)%10,matriz_tipo.index(F)/10)]

    matriz_jogo_P = []
    matriz_jogo_N = []
    for x in matriz_tipo:
        matriz_jogo_N.append(dic_N[x])
        matriz_jogo_P.append(dic_P[x])

    modifica_angulos()

    f_verificar = False
    mov = 0
    tempo_inicial = jogo[3]
    reseta_tempo = time.clock()

    for x in range(60): #apenas para  caso nao ocorra eventos
        canos[x], angulo[x], movimentos = mov_imagem(angulo[x], posicao_x[x], posicao_y[x], matriz_jogo_N[x], matriz_jogo_P[x])

    while f_verificar == False and ir_menu == False:
        for evento in pygame.event.get():
            if evento.type == QUIT:
                exit()

            if tempo_restante() >= 0.6: ###### Para evitar que a peça seja rotacionada e pare no meio do caminho, Faça o teste: rotacione faltando em torno de 0.5 segundos para o tempo final
                for x in range(60):
                    canos[x], angulo[x], movimentos = mov_imagem(angulo[x], posicao_x[x], posicao_y[x], matriz_jogo_N[x], matriz_jogo_P[x])
                    mov += movimentos

        resultado, f_verificar = verificacao()	# resultado - ganhou ou perdeu - é utilizado na funcao tela final

        if f_verificar == True:
            fase_jogo,tentativa, pontuacao, ir_menu = tela_final(fase_jogo,tentativa, pontuacao, ir_menu, nome)#

        atualizacao()
